The inexorable advance of all dimensions of the internet has fostered the appearance of semantic data. Semantic data often takes the form of RDF data (Resource Description Framework data) that comports with standardized data storage models (e.g., W3C standard-based data storage models) that include representation of information in such a way as to enable computer-aided interpretation of the meaning or meanings (e.g., semantics) from the data without the need to know the specifics of its schema or meta-model. Such semantic data representations are often fact oriented. Facts are typically expressed by binary relations between data elements, and binary relations often take the form of triples that specify two objects and a relation between the two objects. Strictly as an illustrative example, a triple can be of the construction:                Object1<RelationType>Object2which construction carries a relationship between two things such as the relationship where the “Eiffel Tower” (Object1) “<is located in>” “Paris” (Object2).        
Often large amounts of semantic data such as RDF data are stored at and/or made accessible at remote computing nodes. In some cases RDF data is stored remote computing nodes in disparate geographies, and accessible over the internet using a URL or URI. Often, the term “linked data” refers to a method of publishing RDF data or other structured data so that it can be interlinked and readily accessed on the web. Linked data is sometimes built on a suite of World Wide Web Consortium (W3C) technologies.
Unfortunately, access to such RDF data is hampered by legacy techniques in that legacy access requires the RDF data to be pre-accessed and/or pre-staged by middleware before the RDF data can be accessed by the database engine (e.g., to be combined with local relational data). It would be convenient to have a native database query (e.g., in a native database language such as SQL) such that access to a remote RDF repository can be made via an HTTP URL address such as “<http://domainname.com/RDFDATA>” that can be made natively in a single query, the results of which query are combinable with local relational data—all without having to pre-access and/or pre-stage RDF data.
RDF data is often stored at remote endpoints termed SPARQL endpoints (aka SPARQL Protocol and RDF Query Language endpoints). SPARQL endpoints are network-accessible locations (e.g., computing nodes) that are addressable (e.g., by a network address such as a URL), at which location a SPARQL query can be performed (e.g., over RDF data). In many situations, public or parapublic organizations or institutions assemble RDF data, and post for internet access. For example, “dbpedia.org” represents a global community effort to extract structured information from periodic Wikipedia dumps, and to make this information available on the web. It is served to the public via a live instance of a SPARQL endpoint at “http://dbpedia.org/”.
Some SPARQL endpoints have the characteristic that they can receive and process SPARQL queries and/or other service requests. Such SPARQL endpoints comprise a computer node accessible over the internet, such that a SPARQL endpoint can be accessed and directed (e.g., by a caller from another computer) to process a SPARQL query, and return results to the caller. The SPARQL results can then be further processed, including combining the SPARQL results with other data and/or generating reports, etc.
In certain legacy systems, after executing a SPARQL query at a SPARQL endpoint, the SPARQL results are stored (e.g., as locally-stored RDF data) for later access, which later access might include performing local queries over the corpus of locally-stored RDF data. Such local queries return results (e.g., as a table of values). This access technique (e.g., using a table function) can include combining locally-stored RDF data with locally-stored relational data so as to provide access to SPARQL query results in the same context as access to relational data. For example, relational tables can be joined with SPARQL query results, and tables and views can be created from SPARQL query results.
However, the legacy access techniques are only able to query locally-stored RDF data. This limitation is exacerbated when the size of the RDF data becomes large, thus incurring large resource requirements to move the RDF data from a SPARQL endpoint to a corpus of locally-stored RDF data. What is needed is a technique or techniques for specifying a single query in one database system context (e.g., an SQL query within a database system) wherein the single query specifies access to non-local RDF data that is brought into the aforementioned database system context.